;
(function($, window, document, undefined) {
	'use strict';

	var eyc = {};

	/***************************************************************************
	 * ********************************* BIZ *********************************
	 **************************************************************************/


	/***************************************************************************
	 * ********************************* UTIL *********************************
	 **************************************************************************/

	// 前一页面ID
	eyc.prePageId = "";


	/**
	 * 工具接口
	 */
	eyc.util = {

		 isJson : function (obj) {
			let isjson = typeof(obj) == "object" && Object.prototype.toString.call(obj).toLowerCase() == "[object object]" && !obj.length;
			return isjson;
		},

		// 对象比较
		objEquals : function(obj1, obj2, propertyName) {
			return objEquals(obj1, obj2, propertyName);
		},

		// 对象深度比较（isFuzzy=true模糊的，没有属性和空、空字符串认为相等）
		objDeepCompare : function(obj1, obj2, isFuzzy) {
			if (isFuzzy)
				return objDeepCompareFuzzy(obj1, obj2);
			return objDeepCompare(obj1, obj2);
		},

		// 对象在ARRAY中的位置
		objInArray : function(array, obj, propertyName) {
			return objInArray(array, obj, propertyName);
		},

		// 移出ARRAY中的对象
		arrayRemove : function(array, obj, propertyName) {
			return arrayRemove(array, obj, propertyName);
		},

		// 对象深拷贝
		objDeepClone : function(obj) {
			return objDeepClone(obj);
		},

		// 字符串为空判断
		stringIsBlank : function(str) {
			return stringIsBlank(str);
		},

		// 字符串非空判断
		stringIsNotBlank : function(str) {
			return !stringIsBlank(str);
		},

		// 字符串TRIM
		stringTrim : function(str) {
			return stringTrim(str);
		},

		// 判断字符串开始
		stringStartWith : function(str, start) {
			return stringStartWith(str, start);
		},

		// 时间格式化（format：如"yyyy-MM-dd"）
		dateFormat : function(date, format) {
			return dateFormat(date, format);
		},

		toDateString : function(date, format) {
			if (!layui || !layui.util) {
				console.error("Please load 'util' module");
				return false;
			}

			return layui.util.toDateString(date, format);
		},

		// 将时间字符串转化为特定的时间格式
		dateStrFormat : function(dateStr, format) {
			return dateStrFormat(dateStr, format);
		},

		// 日期格式是否匹配
		dateFormatMatch : function(dateStr, format) {
			return dateFormatMatch(dateStr, format);
		},

		// 数字前置补零
		digit : function(num, length) {
			return digit(num, length);
		},

		// 会话级本地存储
		sessionStorage : function(table, settings) {
			return layui.sessionData(table, settings);
		},

		// 持久化本地存储
		localStorage : function(table, settings) {
			return layui.data(table, settings);
		},

		// 持久化本地存储
		localStorageKeyValue : function(table, key, value) {
			return localStorageKeyValue(table, key, value);
		},

		// 下载文件
		downloadFile : function(url,params){
			return downloadFile(url, params)
		},
	};



	// 对象比较
	function objEquals(obj1, obj2, propertyName) {
		if (!obj1 && obj2)
			return false;
		if (obj1 && !obj2)
			return false;
		if (!obj1 && !obj2)
			return true;
		if (obj1 == obj2)
			return true;
		if (typeof (obj1) != typeof (obj2))
			return false;

		// IE如果是String，Object方法会报错
		if (typeof (obj1) == "string" && typeof (obj2) == "string") {
			return obj1 == obj2;
		}

		var aProps = Object.keys(obj1);
		var bProps = Object.keys(obj2);

		// 比较所有对象
		if (!propertyName) {
			if (aProps.length != bProps.length) {
				return false;
			}

			for (var i = 0; i < aProps.length; i++) {
				var propName = aProps[i];

				if (obj1[propName] !== obj2[propName]) {
					return false;
				}
			}
		}
		// 比较单个属性
		else {
			if (obj1[propertyName] !== obj2[propertyName]) {
				return false;
			}
		}

		return true;
	}

	// 对象深度比较
	function objDeepCompare(obj1, obj2) {
		function compare(x, y) {
			if (x == null && y == null) {
				return true;
			} else if (x == null && y != null || x != null && y == null) {
				return false;
			} else if (typeof (x) === 'object' && typeof (y) !== 'object') {
				return false;
			} else if (typeof (x) !== 'object' && typeof (y) !== 'object') {
				return x === y;
			} else {
				var rs = true;
				for ( var p in x) {
					if (typeof x[p] != 'function') {
						if (y.hasOwnProperty(p)) {
							rs = compare(x[p], y[p]);
						} else {
							rs = false;
						}
						if (!rs) {
							break;
						}
					}
				}
				return rs;
			}
		}

		if (obj1 != null && obj2 != null) {
			return compare(obj1, obj2) && compare(obj2, obj1);
		} else {
			if (obj1 == null && obj2 == null) {
				return true;
			} else {
				return false;
			}
		}
	}

	function objDeepCompareFuzzy(obj1, obj2) {
		function compare(x, y) {
			if (!x && !y) {
				return true;
			} else if (!x && y || x && !y) {
				return false;
			} else if (typeof (x) === 'object' && typeof (y) !== 'object') {
				return false;
			} else if (typeof (x) !== 'object' && typeof (y) !== 'object') {
				return x === y;
			} else {
				var rs = true;
				for ( var p in x) {
					if (typeof x[p] != 'function') {
						if (y.hasOwnProperty(p)) {
							rs = compare(x[p], y[p]);
						} else if (x[p]) {
							rs = false;
						}
						if (!rs) {
							break;
						}
					}
				}
				return rs;
			}
		}

		if (obj1 && obj2) {
			return compare(obj1, obj2) && compare(obj2, obj1);
		} else {
			if (!obj1 && !obj2) {
				return true;
			} else {
				return false;
			}
		}
	}

	// 对象在ARRAY中的位置
	function objInArray(array, obj, propertyName) {
		if (!array && obj)
			return -1;
		if (!obj)
			return -1;

		if (array instanceof Array) {
			for (var i = 0; i < array.length; i++) {
				if (eyc.util.objEquals(array[i], obj, propertyName))
					return i;
			}
		} else if (eyc.util.objEquals(array, obj, propertyName))
			return 0;

		return -1;
	}

	// ARRAY移出某个对象
	function arrayRemove(array, obj, propertyName) {
		var i = eyc.util.objInArray(array, obj, propertyName)
		if (i < 0)
			return true;

		if (array instanceof Array) {
			array.splice(i, 1);
		}
		return true;
	}

	// 对象深拷贝
	function objDeepClone(obj) {
		if (obj == null)
			return null;

		var newObj = {};
		if (obj instanceof Array) {
			newObj = [];
		}
		for ( var key in obj) {
			var val = obj[key];
			newObj[key] = typeof val === 'object' ? objDeepClone(val) : val;
		}
		return newObj;
	}

	// 字符串为空判断
	function stringIsBlank(str) {
		if (str != null) {
			if (str === undefined || str === "" || eyc.util.stringTrim(str) === '' || str === "null"
					|| str.length === 0 || str === "undefined") {
				return true;
			} else {
				return false;
			}
		} else {
			return true;
		}
	}

	// 字符串TRIM
	function stringTrim(str) {
		if (str != undefined && str != null && typeof (str) == 'string') {
			return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
		}
	}

	// 判断字符串开始
	function stringStartWith(str, start) {
		var reg = new RegExp("^" + start);
		if (reg.test(str)) {
			return true;
		} else {
			return false;
		}
	}

	// 数字前置补零
	function digit(num, length) {
		var str = '';
		num = String(num);
		length = length || 2;
		for (var i = num.length; i < length; i++) {
			str += '0';
		}
		return num < Math.pow(10, length) ? str + (num | 0) : num;
	}

	// 时间格式化（format：如"yyyy-MM-dd"）
	function dateFormat(date, format) {
		var o = {
			"M+" : date.getMonth() + 1, // 月份
			"d+" : date.getDate(), // 日
			"h+" : date.getHours(), // 小时
			"H+" : date.getHours(), // 小时
			"m+" : date.getMinutes(), // 分
			"s+" : date.getSeconds(), // 秒
			// "q+": Math.floor((date.getMonth() + 3) / 3), // 季度
			"S" : date.getMilliseconds(),// 毫秒
		};
		if (/(y+)/.test(format))
			format = format.replace(RegExp.$1, (date.getFullYear() + "").substr(4 - RegExp.$1.length));

		for ( var k in o)
			if (new RegExp("(" + k + ")").test(format))
				format = format.replace(RegExp.$1, (RegExp.$1.length == 1) ? (o[k]) : (("00" + o[k])
						.substr(("" + o[k]).length)));
		return format;
	}

	// 日期格式是否匹配
	function dateFormatMatch(dateStr, format) {
		if (!dateStr || !format)
			return false;

		var dateType = 'yyyy|y|MM|M|dd|d|HH|H|mm|m|ss|s';

		// 将日期格式转化成数组
		var formats = format.match(new RegExp(dateType + '|.', 'g')) || [];

		// 生成正则表达式
		var EXP_IF = '';
		$(formats).each(function(i, item) {
			var EXP = new RegExp(dateType).test(item) ? '\\d{' + function() {
				if (new RegExp(dateType).test(format[i === 0 ? i + 1 : i - 1] || '')) {
					if (/^yyyy|y$/.test(item))
						return 4;
					return item.length;
				}
				if (/^yyyy$/.test(item))
					return '1,4';
				if (/^y$/.test(item))
					return '1,308';
				return '1,2';
			}() + '}' : '\\' + item;
			EXP_IF = EXP_IF + EXP;
		});
		EXP_IF = new RegExp('^' + EXP_IF + '$');
		return EXP_IF.test(dateStr);
	}

	// 将时间字符串转化为特定的时间格式
	function dateStrFormat(dateStr, format) {
		// 防止转化出错
		try {
			// 分割为数组
			var dateTypes = [ 'yyyy', 'MM', 'dd', 'HH', 'mm', 'ss' ];
			var dateType = 'yyyy|y|MM|M|dd|d|HH|H|mm|m|ss|s';
			var formats = format.match(new RegExp(dateType + '|.', 'g')) || [];

			// 将字符串非数字全部变为-
			dateStr = dateStr.replace(/[^0-9]/ig, "-").replace(/-+/g, "-");
			var dateStrs = dateStr.split("-");

			// 重新组装
			var newDate = {
				year : "1",
				month : "0",
				date : "1",
				hours : "0",
				minutes : "0",
				seconds : "0"
			};
			$(formats).each(function(i, item) {
				if (dateStrs.length <= 0)
					return false;

				if (!item || item.length <= 0 || dateTypes.indexOf(item) < 0)
					return true;

				var itemStr = "";
				if (dateStrs[0].length > item.length) {
					itemStr = dateStrs[0].substring(0, item.length);
					dateStrs[0] = dateStrs[0].substring(item.length);
				} else {
					itemStr = dateStrs[0];
					dateStrs.splice(0, 1);
				}

				if (!itemStr || isNaN(itemStr))
					return true;

				if (item.includes("y")) {
					// 少于2位，自动添加20
					if (itemStr.length <= 2) {
						itemStr = "20" + eyc.util.digit(itemStr, 2);
					}
					newDate.year = eyc.util.digit(itemStr, 4);
				} else if (item.includes("M")) {
					newDate.month = parseInt(itemStr) - 1;
				} else if (item.includes("d")) {
					newDate.date = itemStr;
				} else if (item.includes("H")) {
					newDate.hours = itemStr;
				} else if (item.includes("m")) {
					newDate.minutes = itemStr;
				} else if (item.includes("s")) {
					newDate.seconds = itemStr;
				}
			});
			var date = new Date();
			date.setFullYear(newDate.year, newDate.month, newDate.date);
			date.setHours(newDate.hours, newDate.minutes, newDate.seconds);
			dateStr = eyc.util.dateFormat(date, format);
		} catch (err) {
		}

		return dateStr;
	}

	// Local Storage
	function localStorageKeyValue(table, key, value) {
		// 设置缓存
		if (key) {
			var settings = {};
			settings.key = key;
			if (value === null) {
				settings.remove = true;
			} else if (value != undefined && typeof (value) != 'function') {
				settings.value = value;
			}
			eyc.util.localStorage(table, settings);
		}
		return eyc.util.localStorage(table)[key];
	}

	// 下载文件
	function downloadFile(url, params){
		var createElement=function(name,value){
			var input = document.createElement("input");
			input.name = name;
			input.value = value;
			return input;
		};

		var temp = document.createElement("form");
		temp.action = url;
		temp.method = "POST";
		temp.style.display = "none";
		if(params != null){
			$.each(params,function(name,value){
				if(value== null || value == 0){
					return;
				}
				if(typeof value != "object"){
					temp.appendChild(createElement(name,value));
				}else{
					$.each(value,function(i,v){
						if(v == null || v==0){
							return;
						}
						temp.appendChild(createElement(name+"["+i+"]",v));
					});
				}
			});
		}
		document.body.appendChild(temp);
		temp.submit();
		document.body.removeChild(temp);
	};

	/***************************************************************************
	 * ***************************** jQuery AJAX ******************************
	 **************************************************************************/

	/**
	 * AJAX相关接口
	 */
	eyc.ajax = {

		// AJAX默认完成处理
		ajaxComplete : function(XMLHttpRequest, textStatus, notAutoShowMsg) {
			if (self != top)
				parent.eyc.ajax.ajaxComplete(XMLHttpRequest, textStatus, notAutoShowMsg);
			eyc.ui.clearLoading();
		},
		// AJAX默认异常处理
		ajaxError : function(jqXHR, textStatus, errorThrown) {
			if (self != top)
				parent.eyc.ajax.ajaxError(jqXHR, textStatus, errorThrown);
		},
		promise:  function (url,params,stringify) {
			return new Promise(function (resolve, reject) {
				$.ajax({
					url : url,
					type : params? params.method || 'POST':'POST',
					contentType:!params || !params.method || params.method==='POST'? 'application/json;charset=utf-8':'application/x-www-form-urlencoded', //设置请求头信息
					data : stringify===false?params: !params || !params.method || params.method==='POST' ? eyc.util.isJson(params)||Array.isArray(params)?JSON.stringify(params):params:params,
					success : function(rs) {
						if (rs.code === 200) {
							//返回接口的正常数据
							resolve(rs);
						}else{
							resolve(rs);
						}
					},
					fail:function(e) {
						reject(e)
					}
				});
			})
		}

	};

	/***************************************************************************
	 * *********************************** UI *********************************
	 **************************************************************************/

	/**
	 * UI接口
	 */
	eyc.ui = {

		// 常用界面元素赋值
		setValueUiElement : function($cmposite, data) {
			return setValueUiElement($cmposite, data);
		},

		// 清空所有值
		clearValueUiElement : function($cmposite) {
			return clearValueUiElement($cmposite);
		},

		// 获取界面元素值
		getValueUiElement : function($cmposite) {
			return getValueUiElement($cmposite);
		},

		// 设置是否可编辑
		enableUiElement : function($cmposite, isEnable) {
			return enableUiElement($cmposite, isEnable);
		},

		// 设置Input是否可编辑
		enableInput : function($input, isEnable) {
			return enableInput($input, isEnable);
		},

		// 设置Button是否可编辑
		enableBtn : function($btn, isEnable) {
			return enableBtn($btn, isEnable);
		},

		// 设置Select是否可编辑
		enableSelect : function($select, isEnable) {
			return enableSelect($select, isEnable);
		},

		// 根据父元素lay-ignore统一设置所有子元素lay-ignore
		setLayIgnore : function() {
			return setLayIgnore();
		},

		// 初始化表单校验
		initFormVerify : function($cmposite) {
			return initFormVerify($cmposite);
		},

		// 校验控件(可用于非表单提交时)
		verifyUiElement : function($cmposite) {
			return verifyUiElement($cmposite);
		},

		// SelectPage返回结果转换
		selectPageProcessResult : function(rt) {
			return selectPageProcessResult(rt);
		},

		// 显示Loading
		loading : function() {
			return loading();
		},

		// 清除所有Loading
		clearLoading : function() {
			return clearLoading();
		},

		// 获取鼠标所在的位置
		// 参数event事件
		// 返回{x:x,y:y}
		mousePosition : function(ev) {
			return mousePosition(ev);
		},

		// 弹出查询校验信息，与layui-form 校验的风格一致
		// 主要用于无法使用合适的的验证规则时手动弹出校验信息
		showValidMsg : function(msg, success) {
			return showValidMsg(msg, success);
		},



		// 表格列localStorage
		localStorageTableColumn : function(key, value) {
			var cacheTableNme = parent.eyc.resource.getLocalStorageKeys()["TABEL_COLUMN"];
			return eyc.util.localStorageKeyValue(cacheTableNme, key, value);
		},

		// 查询条件localStorage
		localStorageQueryParam : function(key, value) {
			var cacheTableNme = parent.eyc.resource.getLocalStorageKeys()["QUERY_PARAM"];
			return eyc.util.localStorageKeyValue(cacheTableNme, key, value);
		},

		// 下拉列表数据缓存 localStorage
		localStorageDataCombo : function(key, value) {
			var cacheTableNme = parent.eyc.resource.getLocalStorageKeys()["DATA_COMBO"];
			return eyc.util.localStorageKeyValue(cacheTableNme, key, value);
		},

		// 最近使用数据缓存 localStorage
		localStorageDataLatest : function(key, value) {
			var cacheTableNme = parent.eyc.resource.getLocalStorageKeys()["DATA_LATEST"];
			return eyc.util.localStorageKeyValue(cacheTableNme, key, value);
		},

		// 初始化扩展的日期控件
		initDateExtend : function(option) {
			return initDateExtend(option);
		},
	};

	// 常用界面元素赋值
	function setValueUiElement($cmposite, data) {
		if (!data)
			data = {};

		$cmposite.find('input:not(:checkbox):not(:radio)').each(function() {
			$(this).val(data[this.name]);
		});

		$cmposite.find('textarea').each(function() {
			$(this).val(data[this.name]);
		});

		$cmposite.find('input:checkbox').each(function() {
			if (data[this.name])
				$(this).prop("checked", true);
			else
				$(this).prop("checked", false);
		});

		$cmposite.find('select').each(function() {
			var inputValue = data[this.name];
			// 如果布尔型
			if (typeof data[this.name] == 'boolean') {
				if (inputValue)
					inputValue = "true";
				else
					inputValue = "false";
			}

			$(this).val(inputValue);
		});

		$cmposite.find('input:radio').each(function() {
			var inputValue = data[this.name];
			// 如果布尔型
			if (typeof data[this.name] == 'boolean') {
				if (inputValue)
					inputValue = "true";
				else
					inputValue = "false";
			}
			if (this.value == inputValue)
				$(this).prop('checked', true);
			else
				$(this).prop('checked', false);
		});

		// 表单渲染
		eyc.ui.setLayIgnore();

		if (!layui || !layui.form) {
			console.error("Please load 'form' module");
			return false;
		}
		if ($cmposite.attr("lay-filter"))
			layui.form.render(null, $cmposite.attr("lay-filter"));
		else
			layui.form.render();
	}

	// 清空所有值
	function clearValueUiElement($cmposite) {
		eyc.ui.setValueUiElement($cmposite, null);

		// SelectPage
		$cmposite.find('input:not(:checkbox):not(:radio)').each(function() {
			$(this).selectPageClear();
		});
	}

	// 获取界面元素值
	function getValueUiElement($cmposite) {
		var data = {};

		$cmposite.find('input:not(:checkbox):not(:radio)[name]').each(function() {
			data[this.name] = $(this).val();
		});

		$cmposite.find('textarea[name]').each(function() {
			data[this.name] = $(this).val();
		});

		$cmposite.find('input:checkbox[name]').each(function() {
			data[this.name] = $(this).is(':checked');
		});

		$cmposite.find('input:radio[name]:checked').each(function() {
			data[this.name] = $(this).val();
		});

		return data;
	}

	// 设置输入值转化为大写
	function setUiElementUpperCase($cmposite) {
		$cmposite.find('.eyc-uppercase').each(function() {
			$(this).keyup(function() {
				this.value = this.value.toUpperCase();
			});
		});
	}

	// 设置是否可编辑
	function enableUiElement($cmposite, isEnable) {
		$cmposite.find('input, textarea').each(function() {
			eyc.ui.enableInput($(this), isEnable);
		});

		$cmposite.find("button").each(function() {
			eyc.ui.enableBtn($(this), isEnable);
		});
		// 表单渲染
		eyc.ui.setLayIgnore();

		if (!layui || !layui.form) {
			console.error("Please load 'form' module");
			return false;
		}
		if ($cmposite.attr("lay-filter"))
			layui.form.render(null, $cmposite.attr("lay-filter"));
		else
			layui.form.render();
	}

	// 设置Input是否可编辑
	function enableInput($input, isEnable) {
		if (isEnable) {
			$input.removeAttr("disabled");
			$input.removeClass("layui-disabled");
		} else {
			$input.attr("disabled", "disabled");
			$input.addClass("layui-disabled");
		}
	}

	// 设置Button是否可编辑
	function enableBtn($btn, isEnable) {
		if (isEnable) {
			$btn.removeAttr("disabled");
			$btn.removeClass("layui-btn-disabled");
		} else {
			$btn.attr("disabled", "disabled");
			$btn.addClass("layui-btn-disabled");
		}
	}

	// 设置Select是否可编辑
	function enableSelect($select, isEnable) {
		if (isEnable) {
			$select.selectPageDisabled(false);
		} else {
			$select.selectPageDisabled(true);
		}
	}

	// 根据父元素lay-ignore统一设置所有子元素lay-ignore
	function setLayIgnore() {
		$("div[lay-ignore]").find('input').each(function() {
			$(this).attr('lay-ignore', '');
		});
		$("div[lay-ignore]").find('select').each(function() {
			$(this).attr('lay-ignore', '');
		});
	}

	// 添加表单校验
	function initFormVerify($cmposite) {
		if (!layui || !layui.form) {
			console.error("Please load 'form' module");
			return false;
		}

		// 校验规则
		layui.form.verify({
			required : eyc.validate.require,
			common : eyc.validate.common,
			email : eyc.validate.email,
			url : eyc.validate.url,
			date : eyc.validate.date,
			identity : eyc.validate.identity,
			number : eyc.validate.number,
			numberPositive : eyc.validate.numberPositive,
			numberPositiveZero : eyc.validate.numberPositiveZero,
			numberNegative : eyc.validate.numberNegative,
			numberNegativeZero : eyc.validate.numberNegativeZero,
			numberInteger : eyc.validate.numberInteger,
			numberPositiveInteger : eyc.validate.numberPositiveInteger,
			numberPositiveIntegerZero : eyc.validate.numberPositiveIntegerZero,
			numberDecimal1 : eyc.validate.numberDecimal1,
			numberDecimal2 : eyc.validate.numberDecimal2,
			numberDecimal3 : eyc.validate.numberDecimal3,
			letters : eyc.validate.letters,
			lettersOrNumber : eyc.validate.lettersOrNumber,
		});

		// 输入限制
		$cmposite.find('input[lay-verify]').each(function() {
			var vers = $(this).attr('lay-verify').split('|');
			var input = $(this);
			$.map(vers, function(ver) {
				// 只能输入数字 - .
				if (ver && ver.indexOf('number') >= 0) {
					input.keyup(function() {
						input.val(input.val().replace(/[^-\d.]/g, ''));
					});
					return;
				}
			});
		});
	}

	// 校验控件(可用于非表单提交时)
	function verifyUiElement($cmposite) {
		if (!layui || !layui.form) {
			console.error("Please load 'form' module");
			return false;
		}

		if (!layui || !layui.layer) {
			console.error("Please load 'layer' module");
			return false;
		}

		if (!$cmposite)
			return false;

		var verifyElem = $cmposite.find('*[lay-verify]:visible');
		var DANGER = 'layui-form-danger', stop = null, verify = layui.form.config.verify;

		// 开始校验
		layui.each(verifyElem, function(_, item) {
			var othis = $(this), vers = othis.attr('lay-verify').split('|'), verType = othis.attr('lay-verType') // 提示方式
			, value = othis.val();

			othis.removeClass(DANGER);
			layui.each(vers, function(_, thisVer) {
				var isTrue // 是否命中校验
				, errorText = '' // 错误提示文本
				, isFn = typeof verify[thisVer] === 'function';

				// 匹配验证规则
				if (verify[thisVer]) {
					var isTrue = isFn ? errorText = verify[thisVer](value, item) : !verify[thisVer][0].test(value);
					errorText = errorText || verify[thisVer][1];

					// 如果是必填项或者非空命中校验，则阻止提交，弹出提示
					if (isTrue) {
						// 提示层风格
						if (verType === 'tips') {
							layui.layer.tips(errorText, function() {
								if (typeof othis.attr('lay-ignore') !== 'string') {
									if (item.tagName.toLowerCase() === 'select' || /^checkbox|radio$/.test(item.type)) {
										return othis.next();
									}
								}
								return othis;
							}(), {
								tips : 1
							});
						} else if (verType === 'alert') {
							layui.layer.alert(errorText, {
								title : '提示',
								shadeClose : true
							});
						} else {
							layui.layer.msg(errorText, {
								icon : 5,
								shift : 6
							});
						}
						item.focus(); // 非移动设备自动定位焦点
						othis.addClass(DANGER);
						return stop = true;
					}
				}
			});
			if (stop)
				return stop;
		});

		if (stop)
			return false;

		return true;
	}

	// 获取鼠标所在的位置
	function mousePosition(ev) {
		ev = ev || window.event;
		if (ev.pageX || ev.pageY) {
			return {
				x : ev.pageX,
				y : ev.pageY
			};
		}
		return {
			x : ev.clientX + document.body.scrollLeft - document.body.clientLeft,
			y : ev.clientY + document.body.scrollTop - document.body.clientTop
		};
	}

	// 弹出查询校验信息
	function showValidMsg(msg, success) {
		var icon = 5;
		if (success != undefined && success) {
			icon = 6;
		}
		parent.layer.open({
			title : "",
			content : msg,
			icon : icon,
			time : 3000,
			anim : 6,
			btn : "",
			shade : 0,
			closeBtn : 0
		});
	}


	// 初始化扩展的日期控件
	function initDateExtend(option) {
		if (!layui || !layui.laydate) {
			console.error("Please load 'laydate' module");
			return false;
		}

		if (!option || !option.elem)
			return false;

		// 不支持RANGE模式
		if (option.range)
			return false;

		if ($(option.elem).length <= 0)
			return false;

		$(option.elem)
				.each(
						function(i, eycelector) {
							var parentSelector = null;
							// 包裹一层PARENT
							if ($(eycelector).parent(".eyc-input-group").length <= 0) {
								$(eycelector).wrap('<div class="eyc-input-group"></div>');
							}

							// 默认设置autoComplete为off
							if (!$(eycelector).attr("autocomplete")) {
								$(eycelector).attr("autocomplete", "off");
							}

							parentSelector = $(eycelector).parent(".eyc-input-group")[0];

							// 图标按钮
							var nextSelector = null, btnSelector = null;
							if ($(eycelector).next(".eyc-input-group-btn").length <= 0) {
								var span = $('<span class="eyc-input-group-btn"></span>');
								$(parentSelector).append(span);
								nextSelector = span[0];
							} else {
								nextSelector = $($(eycelector).next(".eyc-input-group-btn"))[0];
							}

							if ($(nextSelector).children(".layui-btn").length <= 0) {
								var button = $('<button type="button" class="layui-btn layui-btn-sm eyc-btn-normal eyc-btn-outline"></button>');
								var icon = $('<i class="icon iconfont icon-calendar"></i>');
								icon.appendTo(button);
								$(nextSelector).append(button);
								btnSelector = button[0];
							} else {
								btnSelector = $($(nextSelector).children(".layui-btn"))[0];
							}

							var currOption = $.extend(option, {
								elem : eycelector,
								trigger : 'dblclick',
								closeStop : btnSelector,
							});

							// 将默认触发方式改为双击
							layui.laydate.render(currOption);

							// 点击图标触发文本框双击
							$(btnSelector).on("click", function(e) {
								layui.laydate.render($.extend(option, {
									elem : eycelector,
									closeStop : btnSelector,
									show : true,
								}));
								return false;
							});

							// 日期格式化
							$(eycelector).blur(function() {
								var dateStr = $(eycelector).val();
								// 空直接返回
								if (eyc.util.stringIsBlank(dateStr)) {
									$(eycelector).val(null);
									return;
								}

								// 日期格式
								var format = option.format
								if (!format)
									format = 'yyyy-MM-dd';

								// 如果格式符合，直接返回
								if (eyc.util.dateFormatMatch(dateStr, format)) {
									return;
								}

								// 将时间字符串转化为特定的时间格式
								dateStr = eyc.util.dateStrFormat(dateStr, format);
								if (!eyc.util.dateFormatMatch(dateStr, format)) {
									dateStr = eyc.util.dateFormat(new Date(), format);
								}

								$(eycelector).val(dateStr);
							});
						});
	}

	/*
	 * SelectPage
	 */

	// SelectPage返回结果转换
	function selectPageProcessResult(rt) {
		if (!rt.data) {
			return {
				list : null,
				totalRow : 0
			};
		} else if (typeof (rt.data.total) == 'undefined' || rt.data.total == 'undefined') {
			return {
				list : rt.data,
				totalRow : rt.data.length
			};
		} else {
			return {
				list : rt.data.list,
				totalRow : rt.data.total
			};
		}
	}

	/*
	 * Loading
	 */

	function loading() {
		if (!window.layer)
			return;

		layer.load();
	}

	function clearLoading() {
		if (!window.layer)
			return;

		layer.closeAll('loading');
	}

	/**
	 * PQGRID接口
	 */
	eyc.pqGrid = {

		// 初始化
		init : function($table, option, tmplKey) {
			return pqGridInit($table, option, tmplKey);
		},

		// 返回结果转换
		dataResponse : function(rt) {
			return pqGridDataResponse(rt);
		},

		// 查询参数转换
		searchParam : function() {
			return pqGridSearchParam(this);
		},

		// 表格时间编辑器
		dateEditor : function(ui) {
			return pqGridDateEditor(ui);
		},

		// 表格下拉框编辑器
		autoCmplEditor : function(ui, source, minLength, nmeMapping, tableColParams, otherParams, cached,
				changeCallback) {
			return pqGridAutoCmplEditor(ui, source, minLength, nmeMapping, tableColParams, otherParams, cached,
					changeCallback);
		},

		// 获取表格选中的行（oneLeast是否最少选择一行，maxRow最多选中行数）
		getSelectRows : function(table, oneLeast, maxRow) {
			return pqGridGetSelectRows(table, oneLeast, maxRow)
		},

		// 获取表格选中的一行（oneLeast是否最少选择一行）
		getSelectRow : function(table, oneLeast) {
			return pqGridGetSelectRow(table, oneLeast);
		},

		// 获取表格选中的行的指定字段数据（oneLeast是否最少选择一行，maxRow最多选中行数）
		getSelectRowsProperty : function(table, property, oneLeast, maxRow) {
			return pqGridGetSelectRowsProperty(table, property, oneLeast, maxRow);
		},

		// 获取行数
		getLength : function(tb) {
			return pqGridGetLength(tb);
		},

		// 根据IDX获取行
		getRowDataByIdx : function(tb, idx) {
			return pqGridGetRowDataByIdx(tb, idx);
		},

		// 删除表格中选中行
		delSelectRows : function(table) {
			return pqGridDelSelectRows(table);
		},

		// CTRL键选择增强，在cellClick事件中调用，(单元格选择模式使用，行选择模式不需要)
		ctrlSelectSupport : function(event, ui) {
			return pqGridCtrlSelectSupport(event, ui, this.getInstance().grid);
		},

		// SHIFT键选择增强，在selectEnd事件中调用(单元格选择模式使用，行选择模式不需要)
		shiftSelectSupport : function(event, ui) {
			return pqGridShiftSelectSupport(event, ui, this.getInstance().grid);
		},

		// 新增模板
		openAddTmplDialog : function(table, key, callBack) {
			return pqGridOpenAddTmplDialog(table, key, callBack);
		},

		// 编辑模板
		openEditTmplDialog : function(table, key, callBack) {
			return pqGridOpenEditTmplDialog(table, key, callBack);
		},

		// 加载模版
		loadTmpl : function(table, key) {
			return pqGridLoadTmpl(table, key);
		},

		// 加载模版
		loadTmplById : function(table, key, templateId) {
			return pqGridLoadTmplById(table, key, templateId);
		},
		
		// 导出Excel
		exportExcel : function(table, fileName) {
			return pqGridExportExcel(table, fileName);
		}

	};

	/*
	 * PQGTID Start
	 */

	// 初始化
	function pqGridInit($table, option, tmplKey) {
		$.extend(option, $.paramquery.pqGrid.regional['ZH']);
		$.extend(option.pageModel, $.paramquery.pqPager.regional['ZH']);

		// 列头中文
		option = $.extend(option, {
			strSelectAll : "全部"
		});
		option.strConditions = $.extend(option.strConditions, {
			begin : "左匹配",
			between : "区间范围",
			contain : "包含",
			equal : "单选",
			empty : "空值",
			end : "右匹配",
			great : "大于",
			gte : "大于等于",
			less : "小于",
			lte : "小于等于",
			notbegin : "左不匹配",
			notcontain : "不包含",
			notequal : "不等于",
			notempty : "非空",
			notend : "右不匹配",
			range : "多选",
			regexp : "正则表达式"
		});

		// 列头筛选
		if (option.colModel) {
			$(option.colModel).each(function(i, col) {
				col.filter = col.filter || {
					// 默认多选
					crules : [ {
						condition : 'range'
					} ],
					// 默认去除一些模式
					conditionExclude : [ 'notbegin', 'notend', 'regexp', 'empty', 'notempty' ]
				};
			})
		}

		var table = $table.pqGrid(option);

		// 表格模板
		if (tmplKey) {
			var grid = table.pqGrid("getInstance").grid;

			// 当前表格默认状态
			var state = JSON.parse(grid.saveState({
				save : false
			}));

			var templateList = eyc.ui.localStorageTableColumn(tmplKey);
			if (templateList != undefined && templateList.length > 0) {
				$(templateList).each(function(i, e) {
					// 覆盖default
					if (e.isDefault || e.isOrig) {
						e.state = state;
						return false;
					}
				});
			} else {
				var curTemplate = {};
				curTemplate.state = state;
				curTemplate.isOrig = true;
				curTemplate.isSel = false;
				curTemplate.name = "初始表格模版";
				curTemplate.id = "DEFAULT_" + new Date().getTime();
				templateList = [];
				templateList.push(curTemplate);
			}
			eyc.ui.localStorageTableColumn(tmplKey, templateList);
			// 加载选中的模板
			pqGridLoadTmpl(table, tmplKey);
		}

		return table;
	}

	// 返回结果转换
	function pqGridDataResponse(rt) {
		if (rt.code!==200) {
			if (rt.code == 401) {
				parent.eyc.ajax.showLoginDialog();
			} else if (rt.message) {
				parent.layer.msg(rt.message);
			}
			return {
				curPage : 1,
				totalRecords : 0,
				data : []
			};
		} else {
			return {
				curPage : rt.data.pageNum,
				totalRecords : rt.data.total,
				data : rt.data.list
			};
		}
	}

	// 查询参数转换
	function pqGridSearchParam(grid) {
		var pageModel = grid.options.pageModel, sortModel = grid.options.sortModel;
		var requestData = grid.options.requestData;
		var limit = pageModel.rPP;
		var offset = limit * (pageModel.curPage - 1);
		var searchForm = grid.options.searchFormId;
		var searchParam = $(searchForm).serializeObject();

		// form参数
		$.extend(searchParam, {
			limit : limit,
			offset : offset,
			pageNumber: pageModel.curPage>0?pageModel.curPage:1,
			pageSize:limit
		});

		// 额外参数
		$.extend(searchParam, requestData);

		if (sortModel.sorter && sortModel.sorter.length > 0) {
			var sorter = sortModel.sorter[0];
			$.extend(searchParam, {
				sort : sorter.dataIndx,
				order : sorter.dir == "down" ? "DESC" : "ASC"
			});
		}
		return searchParam;
	}

	// 表格时间编辑器
	function pqGridDateEditor(ui) {
		if (!ui)
			return false;

		var tableID = ui.$cell.parent().parent()[0].id;
		var $inp = ui.$cell.find("input");
		var field = ui.dataIndx;
		$inp.attr("id", field);

		// 时间格式类型
		var datetype = "datetime";
		if (ui.column.editor.dateType)
			datetype = ui.column.editor.dateType;

		// 时间格式
		var formatType = {
			year : 'yyyy',
			month : 'yyyy-MM',
			date : 'yyyy-MM-dd',
			time : 'HH:mm:ss',
			datetime : 'yyyy-MM-dd HH:mm:ss'
		};

		var format = formatType[datetype];
		if (!format)
			return false;

		// 日期格式化
		$inp.blur(function() {
			var dateStr = $inp.val();
			// 空直接返回
			if (eyc.util.stringIsBlank(dateStr)) {
				$inp.val(null);
				return;
			}

			// 如果格式符合，直接返回
			if (eyc.util.dateFormatMatch(dateStr, format)) {
				return;
			}

			// 将时间字符串转化为特定的时间格式
			dateStr = eyc.util.dateStrFormat(dateStr, format);
			if (!eyc.util.dateFormatMatch(dateStr, format)) {
				dateStr = eyc.util.dateFormat(new Date(), format);
			}

			// 更新
			var updRow = {};
			updRow[field] = dateStr;
			$("#" + tableID).pqGrid("updateRow", {
				rowIndx : ui.rowIndx,
				newRow : updRow
			});
		});

		// 触发控件显示
		if (layui && layui.laydate) {
			layui.laydate.render({
				elem : '#' + field,
				type : datetype,
				trigger : "dblclick",
				done : function(value, date) {
					var updRow = {};
					updRow[field] = value;
					$("#" + tableID).pqGrid("updateRow", {
						rowIndx : ui.rowIndx,
						newRow : updRow
					});
				}
			});

			// // 延迟10ms触发单击事件，打开时间面板
			// setTimeout(function() {
			// $inp.trigger('click');
			// }, 10);
		}
	}

	// 表格下拉框编辑器
	// source可以为 URL or JSON
	// minLength最少输入长度(source为URL时有效)
	// nmeMapping未额外赋值NAME映射{'字段名', '返回结构属性名'}
	// tableColParams为表格内前置条件参数名{'字段名', '表格属性列'}, 用于联动
	// otherParams为其他前置条件属性值{'字段名', value}, 用于联动
	// cached是否缓存到本地（会话级, source为URL, minLength=0 ,前置条件PARAM无用）
	// changeCallback下拉框Change后回调方法
	function pqGridAutoCmplEditor(ui, source, minLength, nmeMapping, tableColParams, otherParams, cached,
			changeCallback) {
		if (!minLength)
			minLength = 0;

		// 数据源 URL or JSON
		var url, jsonData;
		if ($.isArray(source))
			jsonData = source;
		else
			url = source;

		// 是否缓存
		if (cached && minLength == 0 && url) {
			var cacheTableNme = parent.eyc.resource.getLocalStorageKeys()["DATA_COMBO"];
			var localData = eyc.util.sessionStorage(cacheTableNme);
			if (localData[url])
				jsonData = localData[url];
			else {
				// 无参数，否则缓存意义不大
				$.ajax({
					url : url,
					type : 'GET',
					async : false,
					success : function(rt) {
						if (rt.code===200) {
							var data = rt.data;
							if (typeof (data.total) == 'undefined' || data.total == 'undefined')
								jsonData = data;
							else
								jsonData = data.list;// 返回的是分页结构

							eyc.util.sessionStorage(cacheTableNme, {
								key : url,
								value : jsonData
							})
						}
					}
				});
			}
		}

		var tableID = ui.$cell.parent().parent()[0].id;
		var $inp = ui.$cell.find("input");
		var autocmpl = $inp.autocomplete({
			source : jsonData ? jsonData : function(request, response) {
				var param = {
					inputText : request.term
				};
				if (tableColParams) {
					var condition = {};
					var params = {};
					$.each(tableColParams, function(i) {
						condition[i] = ui.rowData[this];
						params[i] = ui.rowData[this];
					});
					$.extend(param, condition);
					if (param["params"] == null) {
						param["params"] = {};
					}
					$.extend(param.params, params);
				}
				if (otherParams) {
					var condition = {};
					var params = {};
					$.each(otherParams, function(i) {
						condition[i] = this;
						params[i] = this;
					});
					$.extend(param, condition);
					if (param["params"] == null) {
						param["params"] = {};
					}
					$.extend(param.params, params);
				}
				$.ajax({
					url : url,
					type : 'GET',
					data : param,
					success : function(rt) {
						if (rt.code===200) {
							var data = rt.data;
							if (typeof (data.total) == 'undefined' || data.total == 'undefined')
								response(data);
							else
								response(data.list);// 返回的是分页结构
						}
					}
				});
			},
			autoFocus : true,
			minLength : minLength,
			change : function(event, obj) {
				var allCols = $("#" + tableID).pqGrid("getColModel").map(x => {return x.dataIndx}); 
				var updRow = {};
				if (obj.item != null) {
					updRow[ui.dataIndx] = obj.item.label;
					if (nmeMapping) {
						for ( var field in nmeMapping) {
							var value = '';
							if (obj.item[nmeMapping[field]])
								value = obj.item[nmeMapping[field]];
							else if (obj.item.extraInfoMap[nmeMapping[field]])
								value = obj.item.extraInfoMap[nmeMapping[field]];
									
							// 如果不在表格列中，不能更新updRow
							if (allCols.indexOf(field) >= 0)
								updRow[field] = value;
							else
								ui.rowData[field] = value;		
						}
					}
				} else {
					updRow[ui.dataIndx] = '';
					for ( var field in nmeMapping) {
						if (allCols.indexOf(field) >= 0)
							updRow[field] = '';
						else
							ui.rowData[field] = '';
					}
				}

				$("#" + tableID).pqGrid("updateRow", {
					rowIndx : ui.rowIndx,
					newRow : updRow,
					checkEditable : false
				});

				if (changeCallback && typeof (changeCallback) === 'function') {
					changeCallback();
				}
			}
		});

		if (minLength == 0) {
			autocmpl.focus(function() {
				$(this).autocomplete("search", "");
			});
		}

		return autocmpl;
	}

	// 获取表格选中的行（oneLeast是否最少选择一行，maxRow最多选中行数）
	function pqGridGetSelectRows(table, oneLeast, maxRow) {
		if (oneLeast == null)
			oneLeast = false;

		if (maxRow == null)
			maxRow = false;
		if (maxRow === true)
			maxRow = 1;

		table = $(table);
		var grid = table.pqGrid("getInstance").grid;
		var selectRows = grid.SelectRow().getSelection();
		if (!selectRows && !oneLeast) {
			return;
		}
		if (oneLeast && (!selectRows || selectRows.length == 0)) {
			parent.layer.msg('请选择一条数据');
			return;
		}
		if (maxRow && selectRows.length > maxRow) {
			parent.layer.msg('请选择一条数据');
			return;
		}
		return selectRows;
	}

	// 获取表格选中的一行（oneLeast是否最少选择一行）
	function pqGridGetSelectRow(table, oneLeast) {
		oneLeast=oneLeast||true;
		var rowList = eyc.pqGrid.getSelectRows(table, oneLeast, 1);
		if (!rowList)
			return;
		return rowList[0];
	}

	// 获取表格选中的行的指定字段数据（oneLeast是否最少选择一行，maxRow最多选中行数）
	function pqGridGetSelectRowsProperty(table, property, oneLeast, maxRow) {
		if (oneLeast == null)
			oneLeast = true;

		if (maxRow == null)
			maxRow = false;

		var selectRows = eyc.pqGrid.getSelectRows(table, oneLeast, maxRow);
		if ($.isEmptyObject(selectRows)) {
			return;
		}
		if (!property) {
			return selectRows;
		}
		var properties = $.map(selectRows, function(row) {
			return row.rowData[property];
		});
		if (oneLeast && (!properties || properties.length == 0)) {
			parent.layer.msg('没有选择数据');
			return;
		}
		return properties;
	}

	// 删除表格中选中行
	function pqGridDelSelectRows(table) {
		var grid = table.pqGrid("getInstance").grid;
		var selectList = grid.SelectRow().getSelection();
		for ( var rowNum in selectList) {
			var row = selectList[0];
			if (!row)
				return;
			var crrIndex = row.rowIndx;
			grid.deleteRow({
				rowIndx : crrIndex
			});
		}
	}

	// 获取行数
	function pqGridGetLength(tb) {
		if (tb) {
			var list = tb.pqGrid("option").dataModel.data;
			if (list) {
				return list.length;
			} else {
				return 0
			}
		}
	}

	// 根据IDX获取行
	function pqGridGetRowDataByIdx(tb, idx) {
		if (tb && idx) {
			var list = tb.pqGrid("option").dataModel.data;
			if (list && list.length > 0) {
				return list[idx];
			}
		}
	}

	// CTRL键选择增强，在cellClick事件中调用，(单元格选择模式使用，行选择模式不需要)
	function pqGridCtrlSelectSupport(event, ui, grid) {
		if (grid.option('selectionModel').type == 'cell') {
			// 按住CTRL键 点击单元格 可以多选或取消选择
			if (eyc.event.ctrlKey()) {
				grid.SelectRow().toggle({
					rowIndx : ui.rowIndx
				});
			}
		}
	}

	// SHIFT键选择增强，在selectEnd事件中调用(单元格选择模式使用，行选择模式不需要)
	function pqGridShiftSelectSupport(event, ui, grid) {
		var ranges = ui.selection.address();
		// 按住SHIFT可以多选
		if (eyc.event.shiftKey()) {
			var selectRows = [];
			$(ranges).each(function(i, e) {
				for (var j = e.r1; j <= e.r2; j++) {
					selectRows.push({
						rowIndx : j
					});
				}
			});
			if (selectRows.length > 0)
				grid.SelectRow().add({
					rows : selectRows
				});
		} else if (!eyc.event.shiftKey() && !eyc.event.ctrlKey()) {
			// 点击表格任意单元格(排除掉CheckBox列的单元格)取消所有选择的行
			if (grid.SelectRow().getSelection().length > 0) {
				// 获取CheckBox列
				var cbCol = grid.Columns().find(function(col) {
					return col.type == 'checkbox' || col.cb != undefined;
				});
				if (cbCol == undefined || ranges[0].c1 != cbCol.leftPos) {// 排除掉CheckBox列
					grid.SelectRow().removeAll();
				}
			}
		}
	}

	// 新增模板
	function pqGridOpenAddTmplDialog(table, key, callback) {
		if (!table || !key)
			return false;
		var grid = table.pqGrid("getInstance").grid;
		var curTemplate = {};
		curTemplate.state = JSON.parse(grid.saveState({
			save : false
		}));
		pqGridOpenTmplDialog(table, key, curTemplate, "NEW_TEMPLATE", 450, 260, callback);
	}

	// 编辑模板
	function pqGridOpenEditTmplDialog(table, key, callback) {
		if (!table || !key)
			return false;
		pqGridOpenTmplDialog(table, key, {}, "SHOW_LIST", 450, 500, callback);
	}

	function pqGridOpenTmplDialog(table, key, curTemplate, actionType, width, height, callback) {
		if (!key || !curTemplate || !actionType)
			return false;
		var w = width || 420, h = height || 520;
		var option = {};
		option.type = 2;
		option.title = "表格模版";
		option.area = [ w + 'px', h + 'px' ];
		option.content = '/eyc-web/base/page/pqGridStateTemplateDialog?key=' + key + '&actionType=' + actionType;
		option.success = function(layero, index) {
			var iframeWin = parent.window[layero.find('iframe')[0]['name']];
			iframeWin.curTemplate = curTemplate;
		};
		option.btnAlign = 'c';
		if (actionType == "NEW_TEMPLATE") {
			option.btn = [ '确认', '关闭' ];
			option.yes = function(index, layero) {
				var iframeWin = parent.window[layero.find('iframe')[0]['name']];
				if (actionType == "NEW_TEMPLATE") {
					iframeWin.newTemplate();
				} else if (actionType == "SHOW_LIST") {
					iframeWin.refreshTemplateList();
					pqGridLoadTmpl(table, key);
				}
				if (callback && typeof (callback) === 'function') {
					callback();
				}
			};
		} else if (actionType == "SHOW_LIST") {
			option.btn = [ '确认', '上传', '下载', '关闭' ];
			option.yes = function(index, layero) {
				var iframeWin = parent.window[layero.find('iframe')[0]['name']];
				if (actionType == "NEW_TEMPLATE") {
					iframeWin.newTemplate();
				} else if (actionType == "SHOW_LIST") {
					iframeWin.refreshTemplateList();
					pqGridLoadTmpl(table, key);
				}
				if (callback && typeof (callback) === 'function') {
					callback();
				}
			};
			option.btn2 = function(index, layero) {
				var iframeWin = parent.window[layero.find('iframe')[0]['name']];
				iframeWin.uploadTemplist(key);
				return false
			};
			option.btn3 = function(index, layero) {
				var iframeWin = parent.window[layero.find('iframe')[0]['name']];
				iframeWin.downloadTemplist(key);
				return false
			};
		}
		parent.layer.open(option);
	}

	// 加载模版
	function pqGridLoadTmpl(table, key) {
		var templateList = eyc.ui.localStorageTableColumn(key);
		if (templateList != undefined && templateList.length > 0) {
			$(templateList).each(function(i, e) {
				if (e.isSel) {
					table.pqGrid("getInstance").grid.loadState({
						state : e.state,
						refresh : false
					});
					table.pqGrid("getInstance").grid.refreshView();
					return false;
				}
			});
		}
	}

	// 加载模版2
	function pqGridLoadTmplById(table, key, templateId) {
		var templateList = eyc.ui.localStorageTableColumn(key);
		if (templateList != undefined && templateList.length > 0) {
			$(templateList).each(function(i, e) {
				if (e.id == templateId) {
					if (!e.isSel) {
						e.isSel = true;
						table.pqGrid("getInstance").grid.loadState({
							state : e.state,
							refresh : false
						});
						table.pqGrid("getInstance").grid.refreshView();
					}
				} else {
					e.isSel = false;
				}
			});
			eyc.ui.localStorageTableColumn(key, templateList);
		}
	}

	/**
	 * 列表excel导出,导出选中的行(全选和不选择均为全部导出) 默认不导出checkbox列和hidden列,
	 * 除非该列有reversal值,且reversal对应了正确的列 或者使用了 forceExport:boolean 强制导出参数
	 * exportWithHidden 为true的列会使用相应的隐藏列替换导出 * ( 必要的时候可以利用自定义属性exportWithHidden :
	 * boolean,reversal :string * 配合现有属性exportRender : boolean 导出需要进行前台逻辑处理的列 *
	 * reversal列及其替换的exportWithHidden列可以定义不同rander方法来负责html展示与Excel导出 * 示例请参考
	 * searchAuditWaybill(审核查询) 包装代码导出 ) forceExport:boolean 强制导出
	 * 
	 * @param table_表格
	 * @param fileNme_文件名
	 */
	function pqGridExportExcel(table, fileNme) {
		if (fileNme === undefined || fileNme === null) {
			fileNme = "EXCEL_" + new Date().getTime();
		}
		var tableSelectRow = eyc.pqGrid.getSelectRows(table);
		var selectDate = [];
		$(tableSelectRow).each(function(i, e) {
			selectDate.push(e.rowData);
		});
		if (selectDate.length == 0) {
			selectDate = table.pqGrid("getInstance").grid.pdata;
		}
		if (selectDate.length > 0) {
			var option = {};
			var dataModel = {};
			var colModel = [];
			dataModel.data = selectDate;
			option.dataModel = dataModel;
			var tableColModel = table.pqGrid("option").colModel;
			$(tableColModel).each(function(i, e) {
				// 不导出checkbox列和隐藏的列
				if (e.type !== 'checkbox' && !e.hidden || e.forceExport) {
					var col = {};
					if (e.exportWithHidden) {
						// 用reversal隐藏列替换属性exportWithHidden为真的列
						var e1 = null;
						$(tableColModel).each(function(j, f) {
							if (f.reversal !== undefined && f.reversal === e.dataIndx && f.type !== 'checkbox') {
								e1 = f;
								return false;
							}
						});
						// 替换当前列导出
						if (e1 !== null) {
							col.dataIndx = e1.dataIndx;
							col.title = e1.title;
							col.width = e1.width;
							col.render = e1.render;
							col.exportRender = e1.exportRender;
							colModel.push(col);
						}
					} else {
						col.dataIndx = e.dataIndx;
						col.title = e.title;
						col.width = e.width;
						col.render = e.render;
						col.exportRender = e.exportRender;
						if(e.childCount > 0){
							col.colModel = e.colModel;						
						}
						colModel.push(col);
					}
				}
			});
			option.colModel = colModel;
			$("<div id='tableExcelExport' style='display:none'></div>").appendTo("body");
			var tableExport = eyc.pqGrid.init($("#tableExcelExport"), option);
			var blob = tableExport.pqGrid("exportData", {
				format : 'xlsx',
				render : false
			});
			if (typeof blob === "string") {
				blob = new Blob([ blob ]);
			}
			saveAs(blob, fileNme + ".xlsx");
			$("#tableExcelExport").remove();
		} else {
			parent.layer.alert("缺少导出数据源!");
		}
	}

	/*
	 * PQGTID End
	 */

	/*
	 * Select2，待删除，不要使用
	 */

	// 普通返回结果转化，待删除
	eyc.getDefaultProcessResults = function(data, page) {
		return {
			results : data.data
		};
	}

	// 分页返回结果转化，待删除
	eyc.getPageProcessResults = function(data, params) {
		var limit = getSelectPageLimit();
		params.page = params.page || 1;
		return {
			results : data.data.rows,
			pagination : {
				more : (params.page * limit) < data.data.total
			}
		};
	}

	// 分页参数转化，待删除
	eyc.getPageData = function(params) {
		var offset;
		var limit = getSelectPageLimit();
		if (params.page) {
			offset = (params.page - 1) * limit;
		} else {
			offset = 0;
		}
		return {
			inputText : params.term,
			offset : offset,
			limit : limit
		};
	}

	// 分页每页条数，待删除
	eyc.getSelectPageLimit = function() {
		return 20;
	}

	/***************************************************************************
	 * ******************************** Validate********************************
	 **************************************************************************/

	/**
	 * 校验规则
	 */
	eyc.validate = {
		// 必填项
		require : function(value) {
			if (!value || !/[\S]+/.test(value))
				return '必填项不能为空'
		},
		// 普通字符（字母、数字、下划线、横杠、空格、括号、中文）
		common : function(value) {
			if (value) {
				if (!/^[a-zA-Z0-9_\-\s\()\u4e00-\u9fa5]+$/.test(value))
					return '只能填写字母、数字、下划线、横杠、空格、括号或中文'
			}
		},
		// 邮箱格式
		email : function(value) {
			if (value) {
				if (!/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/.test(value))
					return '邮箱格式不正确'
			}
		},
		// 链接格式
		url : function(value) {
			if (value) {
				if (!/(^#)|(^http(s*):\/\/[^\s]+\.[^\s]+)/.test(value))
					return '链接格式不正确'
			}
		},
		// 日期格式
		date : function(value) {
			if (value) {
				if (!/^(\d{4})[-\/](\d{1}|0\d{1}|1[0-2])([-\/](\d{1}|0\d{1}|[1-2][0-9]|3[0-1]))*$/.test(value))
					return '日期格式不正确'
			}
		},
		// 身份证号
		identity : function(value) {
			if (value) {
				if (!/(^\d{15}$)|(^\d{17}(x|X|\d)$)/.test(value))
					return '请输入正确的身份证号'
			}
		},
		// 数字
		number : function(value) {
			if (value) {
				if (isNaN(value))
					return '只能填写数字'
			}
		},
		// 正数
		numberPositive : function(value) {
			if (value) {
				if (isNaN(value) || value <= 0)
					return '只允许填正数'
			}
		},
		// 正数和零
		numberPositiveZero : function(value) {
			if (value) {
				if (isNaN(value) || value < 0)
					return '只允许填正数和零'
			}
		},
		// 负数
		numberNegative : function(value) {
			if (value) {
				if (isNaN(value) || value >= 0)
					return '只允许填负数'
			}
		},
		// 负数和零
		numberNegativeZero : function(value) {
			if (value) {
				if (isNaN(value) || value > 0)
					return '只允许填负数和零'
			}
		},
		// 整数
		numberInteger : function(value) {
			if (value) {
				if (!/^-?\d+$/.test(value))
					return '只允许填整数'
			}
		},
		// 正整数
		numberPositiveInteger : function(value) {
			if (value) {
				if (!/^[1-9]*[1-9][0-9]*$/.test(value))
					return '只允许填正整数'
			}
		},
		// 正整数和零
		numberPositiveIntegerZero : function(value) {
			if (value) {
				if (!/^([1-9]\d*|[0]{1,1})$/.test(value))
					return '只允许填正整数和零'
			}
		},
		// 最多一位小数
		numberDecimal1 : function(value) {
			if (value) {
				if (!/^-?\d+(\.\d{1,1})?$/.test(value))
					return '只能填写数字，且最多允许一位小数'
			}
		},
		// 最多两位小数
		numberDecimal2 : function(value) {
			if (value) {
				if (!/^-?\d+(\.\d{1,2})?$/.test(value))
					return '只能填写数字，且最多允许两位小数'
			}
		},
		// 最多三位小数
		numberDecimal3 : function(value) {
			if (value) {
				if (!/^-?\d+(\.\d{1,3})?$/.test(value))
					return '只能填写数字，且最多允许三位小数'
			}
		},
		// 字母
		letters : function(value) {
			if (value) {
				if (!/^[A-Za-z]+$/.test(value))
					return '只能填写字母'
			}
		},
		// 数字或字母
		lettersOrNumber : function(value) {
			if (value) {
				if (!/^[0-9A-Za-z]+$/.test(value))
					return '只能填写数字或字母'
			}
		},
	}

	/***************************************************************************
	 * ******************************** Event********************************
	 **************************************************************************/

	/**
	 * 事件
	 */
	eyc.event = {

		// 是否按住ALT键
		altKey : function() {
			return isKeyDown(18);
		},

		// 是否按住CTRL键
		ctrlKey : function() {
			return isKeyDown(17);
		},

		// 是否按住SHIFT键
		shiftKey : function() {
			return isKeyDown(16);
		},
	};

	var keyCdes = [];

	function eventInit() {
		// 键盘监控
		$(window).keydown(function(evt) {
			var keyCde = evt.keyCode || evt.which || '';
			if (!keyCde)
				return;

			if (keyCde != 16 && keyCde != 17 && keyCde != 18)
				return;

			if (keyCdes.indexOf(keyCde) < 0)
				keyCdes.push(keyCde);
		});

		$(window).keyup(function(evt) {
			var keyCde = evt.keyCode || evt.which || '';
			eyc.util.arrayRemove(keyCdes, keyCde);
		});

		$(window).blur(function() {
			keyCdes = [];
		});
	}

	// 是否指定键按下
	function isKeyDown(keyCde) {
		if (!keyCde)
			return false;

		return keyCdes.indexOf(keyCde) >= 0;
	}

	/***************************************************************************
	 * ******************************** 初始化 *********************************
	 **************************************************************************/

	/**
	 * 初始化
	 */
	eyc.init = function() {
		// jQuery AJAX 全局的参数
		$.ajaxSetup({
			contentType : "application/json",
			dataType : 'json',
			complete : eyc.ajax.ajaxComplete,
			error : eyc.ajax.ajaxError
		});

		// 扩展JQUERY表单提交serializeObject
		$.fn.serializeObject = function() {
			var o = {};
			var a = this.serializeArray();
			$.each(a, function() {
				if (o[this.name] !== undefined && o[this.name] !== null) {
					if (!o[this.name].push) {
						o[this.name] = [ o[this.name] ];
					}
					o[this.name].push(this.value || null);
				} else {
					o[this.name] = this.value || null;
				}
			});
			return o;
		};

		// 时间格式化
		Date.prototype.format = function(format) {
			return dateFormat(this, format);
		};

		// LAY UI 扩展模块
		if (typeof (layui) != 'undefined') {
			layui.config({
				base : '/layui/lay/modules/ext/'
			}).extend({
				dropdown : 'dropdown'
			});
		}

		// EVENT初始化
		eventInit();
	};

	window.eyc = eyc;

}(jQuery, window, document));

eyc.init();